const User = require('../models/user');
const bcrypt = require('bcryptjs');
const JWT = require('../utils/jwt');
const config = require('../config/config.default');

const userController = {
  // 用户注册
  async register(req, res, next) {
    try {
      const { username, email, password, phone, studentId, avatar } = req.body;

      // 数据验证
      if (!username || !email || !password || !phone || !studentId || !avatar) {
        return res.status(400).json({
          success: false,
          message: '所有字段（包括头像）都是必填的'
        });
      }

      // 验证头像URL
      if (!avatar.startsWith(config.baseUrl + '/uploads/')) {
        return res.status(400).json({
          success: false,
          message: '请先上传头像'
        });
      }

      // 检查邮箱格式
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      if (!emailRegex.test(email)) {
        return res.status(400).json({
          success: false,
          message: '邮箱格式不正确'
        });
      }

      // 检查用户是否已存在
      const existingUser = await User.findOne({
        $or: [
          { email },
          { username },
          { studentId }
        ]
      });

      if (existingUser) {
        let message = '用户已存在：';
        if (existingUser.email === email) message += '邮箱已被注册';
        if (existingUser.username === username) message += '用户名已被使用';
        if (existingUser.studentId === studentId) message += '学号已被注册';

        return res.status(400).json({
          success: false,
          message
        });
      }

      // 创建新用户
      const user = new User({
        username,
        email,
        password,
        phone,
        studentId,
        avatar
      });

      await user.save();

      // 生成token
      const token = JWT.generate(user);

      // 返回用户信息（不包含密码）
      const userWithoutPassword = user.toObject();
      delete userWithoutPassword.password;

      res.status(201).json({
        success: true,
        message: '注册成功',
        data: {
          user: userWithoutPassword,
          token
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 管理员注册
  async adminRegister(req, res, next) {
    try {
      const { username, email, password, phone } = req.body;

      // 数据验证
      if (!username || !email || !password || !phone) {
        return res.status(400).json({
          success: false,
          message: '所有字段都是必填的'
        });
      }

      // 检查邮箱格式
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      if (!emailRegex.test(email)) {
        return res.status(400).json({
          success: false,
          message: '邮箱格式不正确'
        });
      }

      // 检查用户是否已存在
      const existingUser = await User.findOne({
        $or: [
          { email },
          { username }
        ]
      });

      if (existingUser) {
        let message = '用户已存在：';
        if (existingUser.email === email) message += '邮箱已被注册';
        if (existingUser.username === username) message += '用户名已被使用';

        return res.status(400).json({
          success: false,
          message
        });
      }

      // 为管理员生成一个唯一的studentId前缀
      const adminPrefix = 'ADMIN-';
      // 使用时间戳确保唯一性
      const timestamp = Date.now().toString();
      // 组合成管理员唯一ID
      const adminStudentId = adminPrefix + timestamp;

      // 创建管理员用户
      const admin = new User({
        username,
        email,
        password,
        phone,
        role: 'admin', // 设置为管理员角色
        studentId: adminStudentId // 为管理员设置特殊的studentId，避免与普通用户冲突
      });

      await admin.save();

      // 生成token
      const token = JWT.generate(admin);

      // 返回用户信息（不包含密码）
      const adminWithoutPassword = admin.toObject();
      delete adminWithoutPassword.password;

      res.status(201).json({
        success: true,
        message: '管理员注册成功',
        data: {
          user: adminWithoutPassword,
          token
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 用户登录
  async login(req, res, next) {
    try {
      const { email, password } = req.body;

      // 数据验证
      if (!email || !password) {
        return res.status(400).json({
          success: false,
          message: '邮箱和密码都是必填的'
        });
      }

      // 查找用户
      const user = await User.findOne({ email });

      if (!user) {
        return res.status(401).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 验证密码
      const isMatch = await bcrypt.compare(password, user.password);
      if (!isMatch) {
        return res.status(401).json({
          success: false,
          message: '密码错误'
        });
      }

      // 检查用户状态
      if (user.status === 'banned') {
        return res.status(403).json({
          success: false,
          message: '账号已被封禁',
          reason: user.statusReason
        });
      }

      // 生成token
      const token = JWT.generate(user);

      // 返回用户信息（不包含密码）
      const userWithoutPassword = user.toObject();
      delete userWithoutPassword.password;

      res.json({
        success: true,
        message: '登录成功',
        data: {
          user: userWithoutPassword,
          token,
          isAdmin: user.role === 'admin'
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取用户信息
  async getProfile(req, res, next) {
    try {
      const user = await User.findById(req.user.userId).select('-password');

      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      res.json({
        success: true,
        data: { user }
      });
    } catch (error) {
      next(error);
    }
  },

  // 更新用户信息
  async updateProfile(req, res, next) {
    try {
      const { username, phone } = req.body;

      // 检查至少有一个字段要更新
      if (!username && !phone) {
        return res.status(400).json({
          success: false,
          message: '请提供要更新的字段'
        });
      }

      // 构建更新对象（只允许更新特定字段）
      const updates = {};
      if (username) updates.username = username;
      if (phone) updates.phone = phone;

      // 更新用户信息
      const user = await User.findByIdAndUpdate(
        req.user.userId,
        updates,
        { new: true, runValidators: true }
      ).select('-password');

      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      res.json({
        success: true,
        message: '用户信息更新成功',
        data: { user }
      });
    } catch (error) {
      next(error);
    }
  },

  // 添加更新头像方法
  async updateAvatar(req, res, next) {
    try {
      const { avatar } = req.body;

      if (!avatar) {
        return res.status(400).json({
          success: false,
          message: '请提供新的头像URL'
        });
      }

      // 验证头像URL
      if (!avatar.startsWith(config.baseUrl + '/uploads/')) {
        return res.status(400).json({
          success: false,
          message: '无效的头像URL'
        });
      }

      const user = await User.findByIdAndUpdate(
        req.user.userId,
        { avatar },
        { new: true }
      ).select('-password');

      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      res.json({
        success: true,
        message: '头像更新成功',
        data: { user }
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取用户公开信息
  async getUserPublicInfo(req, res, next) {
    try {
      const { userId } = req.params;

      const user = await User.findById(userId,
        'username avatar studentId status lastOnlineTime' // 只返回这些公开字段
      );

      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      res.json({
        success: true,
        data: {
          user: {
            userId: user._id,
            username: user.username,
            avatar: user.avatar,
            studentId: user.studentId,
            status: user.status,
            lastOnlineTime: user.lastOnlineTime
          }
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 添加更新密码方法
  async updatePassword(req, res, next) {
    try {
      const { currentPassword, newPassword, confirmPassword } = req.body;

      // 验证请求体
      if (!currentPassword || !newPassword || !confirmPassword) {
        return res.status(400).json({
          success: false,
          message: '当前密码、新密码和确认密码都是必填项'
        });
      }

      // 验证新密码和确认密码是否匹配
      if (newPassword !== confirmPassword) {
        return res.status(400).json({
          success: false,
          message: '新密码和确认密码不匹配'
        });
      }

      // 验证新密码长度
      if (newPassword.length < 6) {
        return res.status(400).json({
          success: false,
          message: '新密码长度不能少于6个字符'
        });
      }

      // 获取用户信息（包含密码）
      const user = await User.findById(req.user.userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 验证当前密码是否正确
      const isMatch = await bcrypt.compare(currentPassword, user.password);
      if (!isMatch) {
        return res.status(401).json({
          success: false,
          message: '当前密码不正确'
        });
      }

      // 更新密码
      user.password = newPassword; // 密码将由pre-save中间件自动加密
      await user.save();

      res.json({
        success: true,
        message: '密码更新成功'
      });
    } catch (error) {
      next(error);
    }
  }
};

// 添加管理员相关方法
const adminMethods = {
  // 管理员获取用户列表 (使用之前在 userController 中的完整版本)
  async getUserList(req, res, next) {
    try {
      const {
        page = 1,
        limit = 10,
        status,
        search,
        role,
        sortBy = 'createdAt',
        sortOrder = 'desc',
        startDate,
        endDate
      } = req.query;
      const skip = (page - 1) * limit;

      // 构建查询条件
      let query = {};

      if (status) {
        query.status = status;
      }

      if (role) {
        query.role = role;
      }

      if (search) {
        query.$or = [
          { username: new RegExp(search, 'i') },
          { email: new RegExp(search, 'i') },
          { studentId: new RegExp(search, 'i') },
          { phone: new RegExp(search, 'i') }
        ];
      }

      // 日期范围过滤
      if (startDate || endDate) {
        query.createdAt = {};
        if (startDate) {
          query.createdAt.$gte = new Date(startDate);
        }
        if (endDate) {
          query.createdAt.$lte = new Date(endDate);
        }
      }

      // 确定排序方式
      const sortOptions = {};
      sortOptions[sortBy] = sortOrder === 'asc' ? 1 : -1;

      // 获取用户列表
      const users = await User.find(query)
        .select('-password')
        .sort(sortOptions)
        .skip(skip)
        .limit(parseInt(limit))
        .populate('statusUpdatedBy', 'username');

      // 获取总数
      const total = await User.countDocuments(query);

      res.json({
        success: true,
        data: {
          users,
          pagination: {
            total,
            page: parseInt(page),
            limit: parseInt(limit),
            pages: Math.ceil(total / limit)
          }
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 更新用户状态
  async updateUserStatus(req, res, next) {
    try {
      const { userId } = req.params;
      const { status, reason } = req.body;

      // 验证状态是否有效
      if (!['normal', 'muted', 'banned'].includes(status)) {
        return res.status(400).json({
          success: false,
          message: '无效的用户状态'
        });
      }

      const user = await User.findById(userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 更新用户状态
      user.status = status;
      user.statusReason = reason || '';
      user.statusUpdatedAt = new Date();
      user.statusUpdatedBy = req.user.userId;

      await user.save();

      // 如果用户被禁言或封号，需要断开其WebSocket连接
      if (['muted', 'banned'].includes(status)) {
        // 获取socket实例
        const chatServer = req.app.get('chatServer');
        const userSocket = chatServer.connectedUsers.get(userId);

        if (userSocket) {
          userSocket.emit('statusUpdated', {
            status,
            reason: reason || ''
          });

          if (status === 'banned') {
            userSocket.disconnect(true);
          }
        }
      }

      res.json({
        success: true,
        message: '用户状态更新成功',
        data: {
          user: {
            ...user.toObject(),
            password: undefined
          }
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取用户详细信息
  async getUserDetail(req, res, next) {
    try {
      const { userId } = req.params;

      const user = await User.findById(userId)
        .select('-password')
        .populate('statusUpdatedBy', 'username');

      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      res.json({
        success: true,
        data: { user }
      });
    } catch (error) {
      next(error);
    }
  },

  // 删除用户
  async deleteUser(req, res, next) {
    try {
      const { userId } = req.params;

      const user = await User.findById(userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 检查要删除的用户是否为管理员
      if (user.role === 'admin') {
        return res.status(403).json({
          success: false,
          message: '无法删除管理员账户'
        });
      }

      await User.findByIdAndDelete(userId);

      res.json({
        success: true,
        message: '用户删除成功'
      });
    } catch (error) {
      next(error);
    }
  },

  // 管理员登录
  async adminLogin(req, res, next) {
    try {
      const { email, password } = req.body;

      // 数据验证
      if (!email || !password) {
        return res.status(400).json({
          success: false,
          message: '邮箱和密码都是必填的'
        });
      }

      // 查找用户
      const user = await User.findOne({ email });

      if (!user) {
        return res.status(401).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 验证密码
      const isMatch = await bcrypt.compare(password, user.password);
      if (!isMatch) {
        return res.status(401).json({
          success: false,
          message: '密码错误'
        });
      }

      // 检查是否是管理员
      if (user.role !== 'admin') {
        return res.status(403).json({
          success: false,
          message: '无权访问管理员系统'
        });
      }

      // 检查用户状态
      if (user.status === 'banned') {
        return res.status(403).json({
          success: false,
          message: '账号已被封禁',
          reason: user.statusReason
        });
      }

      // 生成token
      const token = JWT.generate(user);

      // 返回用户信息（不包含密码）
      const userWithoutPassword = user.toObject();
      delete userWithoutPassword.password;

      res.json({
        success: true,
        message: '管理员登录成功',
        data: {
          user: userWithoutPassword,
          token
        }
      });
    } catch (error) {
      next(error);
    }
  }
};

// 合并所有方法
module.exports = {
  ...userController,
  ...adminMethods
}; 